home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / xconq / period.h < prev    next >
C/C++ Source or Header  |  1995-05-09  |  11KB  |  207 lines
  1. /* Copyright (c) 1987, 1988  Stanley T. Shebs, University of Utah. */
  2. /* This program may be used, copied, modified, and redistributed freely */
  3. /* for noncommercial purposes, so long as this notice remains intact. */
  4.  
  5. #pragma comment(exestr, "@(#) period.h 12.1 95/05/09 ")
  6.  
  7. /* RCS $Header: period.h,v 1.1 88/06/21 12:29:45 shebs Exp $ */
  8.  
  9. /* Structures containing period parameters. */
  10. /* To simplify period compilation, the slots are arranged so that scalar */
  11. /* values are generally grouped together.  However, we're not too hardnosed */
  12. /* about it, and do segregate by general classes of values.  In any case, */
  13. /* the period compiler *must* be kept consistent with these structures. */
  14.  
  15. /* There is only one period object, but it's useful to get all global */
  16. /* period parameters glued into a single structure. */
  17.  
  18. typedef struct a_period {
  19.     char *name;              /* name of period */
  20.     char **notes;            /* designer's notes for period */
  21.     char *fontname;          /* name of font for period (optional) */
  22.     short scale;             /* default width of hex in km */
  23.     short countrysize;       /* radius of country in hexes */
  24.     short mindistance;       /* distance between countries in hexes */
  25.     short maxdistance;       /* distance between countries in hexes */
  26.     short numutypes;         /* number of unit types */
  27.     short numrtypes;         /* number of resource types */
  28.     short numttypes;         /* number of terrain types */
  29.     short numsnames;         /* number of random side names */
  30.     short numunames;         /* number of random unit names */
  31.     short firstutype;        /* starting unit if only one */
  32.     short firstptype;        /* what it will try to produce (check plaus) */
  33.     short knownradius;       /* area around the country that has been seen */
  34.     short allseen;           /* true if all units always seen */
  35.     short counterattack;     /* true if attacks go both ways */
  36.     short nukehit;           /* how big a hit to qualify as nuke */
  37.     short neutrality;        /* how much more difficult to get neutrals */
  38.     short efficiency;        /* efficiency of unit recycling */
  39.     short population;        /* occurrence of populations */
  40.     short hostility;         /* hostility of populace towards units */
  41.     short altroughness;      /* fractal dimension for altitude */
  42.     short wetroughness;      /* fractal dimension for moisture */
  43.     short defaultterrain;    /* type of terrain to subst if unknown */
  44.     short edgeterrain;       /* type of terrain to put on N/S edge */
  45.     short spychance;         /* chance of spying each turn */
  46.     short spyquality;        /* percentage of info gathered when spying */
  47. } Period;
  48.  
  49. /* Unit type descriptions go into a single structure.  This structure */
  50. /* contains every single piece of information about all unit types. */
  51.  
  52. typedef struct utype {
  53.     char uchar;              /* character used in prompts */
  54.     char *name;              /* the name (frequently used!) */
  55.     char *help;              /* one-line description */
  56.     char **notes;            /* longer description */
  57.     char *bitmapname;        /* name of icon file (optional) */
  58.     /* attributes for initialization */
  59.     short incountry;         /* number that a side starts out with */
  60.     short density;           /* number of units per ten thousand hexes */
  61.     short named;             /* true if unit gets randomly-assigned name */
  62.     short alreadyseen;       /* true if unit seen at the outset */
  63.     short favored[MAXTTYPES];  /* chance to be found on given terrain */
  64.     short stockpile[MAXRTYPES];  /* percentage of supply at outset */
  65.     /* attributes for revolt phase */
  66.     short revolt;            /* chance to revolt */
  67.     short surrender;         /* base chance to surrender to nearby unit */
  68.     short siege;             /* extra chance to be captured in siege */
  69.     short attdamage;         /* damage when attrition happens */
  70.     char *attritionmsg;      /* what to say when attrition happens */
  71.     char *accidentmsg;       /* what to say when an accident happens */
  72.     short attrition[MAXTTYPES];  /* chance to lose hp */
  73.     short accident[MAXTTYPES];  /* chance to lose totally */
  74.     /* attributes for build phase */
  75.     short maker;             /* true if unit always builds */
  76.     short startup;           /* extra prod schedule for first from unit */
  77.     short research;          /* extra production schedule for first on side */
  78.     short make[MAXUTYPES];   /* base time to build a unit */
  79.     short tomake[MAXRTYPES]; /* amount of resource needed to build */
  80.     short repair[MAXUTYPES]; /* how many turns to regain a hit point */
  81.     /* attributes for supply phase */
  82.     short survival;          /* how long unit can starve */
  83.     char *starvemsg;         /* what to say when unit runs out of supplies */
  84.     short produce[MAXRTYPES];  /* rate of supply production */
  85.     short productivity[MAXTTYPES];  /* effect of terrain on production */
  86.     short storage[MAXRTYPES];  /* capacity for each type of resource */
  87.     short consume[MAXRTYPES];  /* overhead consumption in each turn */
  88.     short inlength[MAXRTYPES];  /* length of supply line coming in */
  89.     short outlength[MAXRTYPES];  /* length of supply line going out */
  90.     /* attributes for move phase */
  91.     short freemove;          /* true if last move not constrained */
  92.     short speed;             /* maximum theoretical speed in hexes/turn */
  93.     short onemove;           /* true if unit gets exactly one move order */
  94.     short jumpmove;          /* true if unit can jump over other units */
  95.     short moves[MAXTTYPES];  /* additional overhead due to terrain */
  96.     short randommove[MAXTTYPES];  /* randomness of move (.01% per turn) */
  97.     short tomove[MAXRTYPES];  /* supplies used to move with */
  98.     /* attributes for transportation */
  99.     short volume;            /* how much space one part takes */
  100.     short holdvolume;        /* space for passengers */
  101.     short capacity[MAXUTYPES];  /* carrying capacity, by unit type */
  102.     short entertime[MAXUTYPES];  /* moves to get on transport */
  103.     short leavetime[MAXUTYPES];  /* moves to get off transport */
  104.     short bridge[MAXUTYPES];  /* true if transport accessible across terr */
  105.     short mobility[MAXUTYPES];  /* true if unit is useless as occupant */
  106.     /* attributes for viewing */
  107.     short seealways;         /* true if unit view always up-to-date */
  108.     short seebest;           /* chance of seeing other units */
  109.     short seeworst;          /* see chance at max range */
  110.     short seerange;          /* how far unit can see another */
  111.     short visibility;        /* how easily others can see us */
  112.     short conceal[MAXTTYPES];  /* how visible in given terrain */
  113.     /* attributes for combat */
  114.     short parts;             /* max number of parts */
  115.     short hp;                /* max number of hit points */
  116.     short crippled;          /* hp at which unit loses functionality */
  117.     short hitrange;          /* how far away we can shoot from */
  118.     short selfdestruct;      /* true if unit always dies in attack */
  119.     short changeside;        /* chance of actually changing sides */
  120.     short hittime;           /* extra moves to attack */
  121.     short retreat;           /* chance of retreat to avoid a hit */
  122.     short counterable;       /* true if can counterattack */
  123.     short arearadius;        /* how big an area is hit */
  124.     char *destroymsg;        /* what to say when unit dies in combat */
  125.     short hit[MAXUTYPES];    /* chance of hitting other units */
  126.     short defense[MAXTTYPES];  /* how easy to hit in given terrain */
  127.     short damage[MAXUTYPES];  /* how many points it hits for */
  128.     short hitswith[MAXRTYPES];  /* amount of supply used for ammo */
  129.     short hitby[MAXRTYPES];  /* kind of ammo that hits unit */
  130.     short capture[MAXUTYPES];  /* chance of capturing a unit */
  131.     short guard[MAXUTYPES];  /* num parts needed to garrison/guard a capture */
  132.     short protect[MAXUTYPES];  /* effect on occupant on transport etc */
  133.     /* random general attributes */
  134.     short territory;         /* territorial value of unit */
  135.     short isneutral;         /* true if unit can change side or be neutral */
  136.     short maxquality;        /* most veteranness achievable */
  137.     short skillf;             /* effect of quality on attack */
  138.     short disciplinef;        /* effect of quality on defense etc */
  139.     short maxmorale;         /* most possible morale */
  140.     short moralef;           /* effect of morale on combat */
  141.     short control;           /* chance of unit obeying orders */
  142.     short disband;           /* true if unit can be gotten rid of */
  143. } Utype;
  144.  
  145. /* Definition of resource types.  These could maybe go in with utype stuff, */
  146. /* but are more conveniently separated. */
  147.  
  148. typedef struct rtype {
  149.     char rchar;              /* char representing resource */
  150.     char *name;              /* short name of resource */
  151.     char *help;              /* help string about resource */              
  152. } Rtype;
  153.  
  154. /* Definition of terrain types.  Most parameters are to get generation */
  155. /* right; unit interactions are all in utypes. */
  156.  
  157. typedef struct ttype {
  158.     char tchar;              /* char representing type */
  159.     char *name;              /* name of terrain */
  160.     char *color;             /* name of a color for color displays */
  161.     short dark;              /* true if terrain is "dark" */
  162.     short nuked;             /* terrain type after being nuked */
  163.     short minalt;            /* lowest altitude percentile for this type */
  164.     short maxalt;            /* highest altitude percentile for this type */
  165.     short minwet;            /* lowest moisture percentile */
  166.     short maxwet;            /* highest moisture percentile */
  167.     short inhabitants;       /* density of population */
  168.     short independence;      /* character of population */
  169. } Ttype;
  170.  
  171. /* Macros for iterating over period description structures. */
  172.  
  173. #define for_all_unit_types(v)      for (v = 0; v < period.numutypes; ++v)
  174.  
  175. #define for_all_resource_types(v)  for (v = 0; v < period.numrtypes; ++v)
  176.  
  177. #define for_all_terrain_types(v)   for (v = 0; v < period.numttypes; ++v)
  178.  
  179. /* Macros to reduce the number of brackets and explicit structure refs. */
  180.  
  181. #define could_make(u1,u2) (utypes[u1].make[u2] > 0)
  182.  
  183. #define could_repair(u1, u2) (utypes[u1].repair[u2] > 0)
  184.  
  185. #define could_move(u,t) (utypes[u].moves[t] >= 0)
  186.  
  187. #define could_carry(u1,u2) (utypes[u1].capacity[u2] > 0)
  188.  
  189. #define could_hit(u1,u2) (utypes[u1].hit[u2] > 0)
  190.  
  191. #define could_capture(u1,u2) (utypes[u1].capture[u2] > 0)
  192.  
  193. #define impassable(u, x, y) (!could_move((u)->type, terrain_at((x), (y))))
  194.  
  195. /* Declarations of the period description structures.  The structures */
  196. /* themselves will be in a compiled period description. */
  197.  
  198. extern Period period;
  199.  
  200. extern Utype utypes[];
  201.  
  202. extern Rtype rtypes[];
  203.  
  204. extern Ttype ttypes[];
  205.  
  206. extern char *snames[], *unames[];
  207.